home *** CD-ROM | disk | FTP | other *** search
/ Atari Mega Archive 1 / Atari Mega Archive - Volume 1.iso / gnu / gdb / gdb_18s.zoo / values.c < prev    next >
C/C++ Source or Header  |  1992-03-25  |  22KB  |  837 lines
  1. /* Low level packing and unpacking of values for GDB.
  2.    Copyright (C) 1986, 1987 Free Software Foundation, Inc.
  3.  
  4. GDB is distributed in the hope that it will be useful, but WITHOUT ANY
  5. WARRANTY.  No author or distributor accepts responsibility to anyone
  6. for the consequences of using it or for whether it serves any
  7. particular purpose or works at all, unless he says so in writing.
  8. Refer to the GDB General Public License for full details.
  9.  
  10. Everyone is granted permission to copy, modify and redistribute GDB,
  11. but only under the conditions described in the GDB General Public
  12. License.  A copy of this license is supposed to have been given to you
  13. along with GDB so you can know your rights and responsibilities.  It
  14. should be in a file named COPYING.  Among other things, the copyright
  15. notice and this notice must be preserved on all copies.
  16.  
  17. In other words, go ahead and share GDB, but don't try to stop
  18. anyone else from sharing it farther.  Help stamp out software hoarding!
  19. */
  20.  
  21. #include <stdio.h>
  22. #include "defs.h"
  23. #include "param.h"
  24. #include "symtab.h"
  25. #include "value.h"
  26.  
  27. /* The value-history records all the values printed
  28.    by print commands during this session.  Each chunk
  29.    records 60 consecutive values.  The first chunk on
  30.    the chain records the most recent values.
  31.    The total number of values is in value_history_count.  */
  32.  
  33. #define VALUE_HISTORY_CHUNK 60
  34.  
  35. struct value_history_chunk
  36. {
  37.   struct value_history_chunk *next;
  38.   value values[VALUE_HISTORY_CHUNK];
  39. };
  40.  
  41. /* Chain of chunks now in use.  */
  42.  
  43. static struct value_history_chunk *value_history_chain;
  44.  
  45. static int value_history_count;    /* Abs number of last entry stored */
  46.  
  47.  
  48. /* List of all value objects currently allocated
  49.    (except for those released by calls to release_value)
  50.    This is so they can be freed after each command.  */
  51.  
  52. static value all_values;
  53.  
  54. /* Allocate a  value  that has the correct length for type TYPE.  */
  55.  
  56. value
  57. allocate_value (type)
  58.      struct type *type;
  59. {
  60.   register value val;
  61.  
  62.   val = (value) xmalloc (sizeof (struct value) + TYPE_LENGTH (type));
  63.   VALUE_NEXT (val) = all_values;
  64.   all_values = val;
  65.   VALUE_TYPE (val) = type;
  66.   VALUE_LVAL (val) = not_lval;
  67.   VALUE_ADDRESS (val) = 0;
  68.   VALUE_OFFSET (val) = 0;
  69.   VALUE_BITPOS (val) = 0;
  70.   VALUE_BITSIZE (val) = 0;
  71.   VALUE_REPEATED (val) = 0;
  72.   VALUE_REPETITIONS (val) = 0;
  73.   VALUE_REGNO (val) = -1;
  74.   return val;
  75. }
  76.  
  77. /* Allocate a  value  that has the correct length
  78.    for COUNT repetitions type TYPE.  */
  79.  
  80. value
  81. allocate_repeat_value (type, count)
  82.      struct type *type;
  83.      int count;
  84. {
  85.   register value val;
  86.  
  87.   val = (value) xmalloc (sizeof (struct value) + TYPE_LENGTH (type) * count);
  88.   VALUE_NEXT (val) = all_values;
  89.   all_values = val;
  90.   VALUE_TYPE (val) = type;
  91.   VALUE_LVAL (val) = not_lval;
  92.   VALUE_ADDRESS (val) = 0;
  93.   VALUE_OFFSET (val) = 0;
  94.   VALUE_BITPOS (val) = 0;
  95.   VALUE_BITSIZE (val) = 0;
  96.   VALUE_REPEATED (val) = 1;
  97.   VALUE_REPETITIONS (val) = count;
  98.   VALUE_REGNO (val) = -1;
  99.   return val;
  100. }
  101.  
  102. /* Free all the values that have been allocated (except for those released).
  103.    Called after each command, successful or not.  */
  104.  
  105. void
  106. free_all_values ()
  107. {
  108.   register value val, next;
  109.  
  110.   for (val = all_values; val; val = next)
  111.     {
  112.       next = VALUE_NEXT (val);
  113.       free (val);
  114.     }
  115.  
  116.   all_values = 0;
  117. }
  118.  
  119. /* Remove VAL from the chain all_values
  120.    so it will not be freed automatically.  */
  121.  
  122. void
  123. release_value (val)
  124.      register value val;
  125. {
  126.   register value v;
  127.  
  128.   if (all_values == val)
  129.     {
  130.       all_values = val->next;
  131.       return;
  132.     }
  133.  
  134.   for (v = all_values; v; v = v->next)
  135.     {
  136.       if (v->next == val)
  137.     {
  138.       v->next = val->next;
  139.       break;
  140.     }
  141.     }
  142. }
  143.  
  144. /* Return a copy of the value ARG.
  145.    It contains the same contents, for same memory address,
  146.    but it's a different block of storage.  */
  147.  
  148. static value
  149. value_copy (arg)
  150.      value arg;
  151. {
  152.   register value val;
  153.   register struct type *type = VALUE_TYPE (arg);
  154.   if (VALUE_REPEATED (arg))
  155.     val = allocate_repeat_value (type, VALUE_REPETITIONS (arg));
  156.   else
  157.     val = allocate_value (type);
  158.   VALUE_LVAL (val) = VALUE_LVAL (arg);
  159.   VALUE_ADDRESS (val) = VALUE_ADDRESS (arg);
  160.   VALUE_OFFSET (val) = VALUE_OFFSET (arg);
  161.   VALUE_BITPOS (val) = VALUE_BITPOS (arg);
  162.   VALUE_BITSIZE (val) = VALUE_BITSIZE (arg);
  163.   VALUE_REGNO (val) = VALUE_REGNO (arg);
  164.   bcopy (VALUE_CONTENTS (arg), VALUE_CONTENTS (val),
  165.      TYPE_LENGTH (VALUE_TYPE (arg))
  166.      * (VALUE_REPEATED (arg) ? VALUE_REPETITIONS (arg) : 1));
  167.   return val;
  168. }
  169.  
  170. /* Access to the value history.  */
  171.  
  172. /* Record a new value in the value history.
  173.    Returns the absolute history index of the entry.  */
  174.  
  175. int
  176. record_latest_value (val)
  177.      value val;
  178. {
  179.   register int i;
  180.  
  181.   /* Get error now if about to store an invalid float.  */
  182.   if (TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_FLT)
  183.     value_as_double (val);
  184.  
  185.   /* Here we treat value_history_count as origin-zero
  186.      and applying to the value being stored now.  */
  187.  
  188.   i = value_history_count % VALUE_HISTORY_CHUNK;
  189.   if (i == 0)
  190.     {
  191.       register struct value_history_chunk *new
  192.     = (struct value_history_chunk *) xmalloc (sizeof (struct value_history_chunk));
  193.       bzero (new->values, sizeof new->values);
  194.       new->next = value_history_chain;
  195.       value_history_chain = new;
  196.     }
  197.  
  198.   value_history_chain->values[i] = val;
  199.   release_value (val);
  200.  
  201.   /* Now we regard value_history_count as origin-one
  202.      and applying to the value just stored.  */
  203.  
  204.   return ++value_history_count;
  205. }
  206.  
  207. /* Return a copy of the value in the history with sequence number NUM.  */
  208.  
  209. value
  210. access_value_history (num)
  211.      int num;
  212. {
  213.   register struct value_history_chunk *chunk;
  214.   register int i;
  215.   register int absnum = num;
  216.  
  217.   if (absnum <= 0)
  218.     absnum += value_history_count;
  219.  
  220.   if (absnum <= 0)
  221.     {
  222.       if (num == 0)
  223.     error ("The history is empty.");
  224.       else if (num == 1)
  225.     error ("There is only one value in the history.");
  226.       else
  227.     error ("History does not go back to $$%d.", -num);
  228.     }
  229.   if (absnum > value_history_count)
  230.     error ("History has not yet reached $%d.", absnum);
  231.  
  232.   absnum--;
  233.  
  234.   /* Now absnum is always absolute and origin zero.  */
  235.  
  236.   chunk = value_history_chain;
  237.   for (i = (value_history_count - 1) / VALUE_HISTORY_CHUNK - absnum / VALUE_HISTORY_CHUNK;
  238.        i > 0; i--)
  239.     chunk = chunk->next;
  240.  
  241.   return value_copy (chunk->values[absnum % VALUE_HISTORY_CHUNK]);
  242. }
  243.  
  244. /* Clear the value history entirely.
  245.    Must be done when new symbol tables are loaded,
  246.    because the type pointers become invalid.  */
  247.  
  248. void
  249. clear_value_history ()
  250. {
  251.   register struct value_history_chunk *next;
  252.   register int i;
  253.   register value val;
  254.  
  255.   while (value_history_chain)
  256.     {
  257.       for (i = 0; i < VALUE_HISTORY_CHUNK; i++)
  258.     if (val = value_history_chain->values[i])
  259.       free (val);
  260.       next = value_history_chain->next;
  261.       free (value_history_chain);
  262.       value_history_chain = next;
  263.     }
  264.   value_history_count = 0;
  265. }
  266.  
  267. static void
  268. history_info (num_exp)
  269.      char *num_exp;
  270. {
  271.   register int i;
  272.   register value val;
  273.   register int num;
  274.  
  275.   if (num_exp)
  276.     num = parse_and_eval_address (num_exp) - 5;
  277.   else
  278.     num = value_history_count - 9;
  279.  
  280.   if (num <= 0)
  281.     num = 1;
  282.  
  283.   for (i = num; i < num + 10 && i <= value_history_count; i++)
  284.     {
  285.       val = access_value_history (i);
  286.      printf_filtered ("$%d = ", i);
  287.       value_print (val, stdout, 0);
  288.      printf_filtered ("\n");
  289.     }
  290. }
  291.  
  292. /* Internal variables.  These are variables within the debugger
  293.    that hold values assigned by debugger commands.
  294.    The user refers to them with a '$' prefix
  295.    that does not appear in the variable names stored internally.  */
  296.  
  297. static struct internalvar *internalvars;
  298.  
  299. /* Look up an internal variable with name NAME.  NAME should not
  300.    normally include a dollar sign.
  301.  
  302.    If the specified internal variable does not exist,
  303.    one is created, with a void value.  */
  304.  
  305. struct internalvar *
  306. lookup_internalvar (name)
  307.      char *name;
  308. {
  309.   register struct internalvar *var;
  310.  
  311.   for (var = internalvars; var; var = var->next)
  312.     if (!strcmp (var->name, name))
  313.       return var;
  314.  
  315.   var = (struct internalvar *) xmalloc (sizeof (struct internalvar));
  316.   var->name = concat (name, "", "");
  317.   var->value = allocate_value (builtin_type_void);
  318.   release_val